package com.wjf.birdfish.util;

public class WhereClause {
	        private String keyOr = "  OR";

	        private String keyAnd = " AND";

	        private int keyLen = 4;

	        private boolean useDefaultANDLinkKey = false;

	        private StringBuffer buffer = new StringBuffer();

	        /**
	         * 
	         * @param useDefaultOrLinkKey
	         *            如果是true，则在不指定OR，或AND时，自动用AND连接
	         */
	        public WhereClause(boolean useDefaultANDLinkKey)
	        {
	            buffer = new StringBuffer();
	            this.useDefaultANDLinkKey = useDefaultANDLinkKey;
	        }

	        private boolean UseDefaultLinkKey()
	        {
	            return (!(IsLast(keyOr) || IsLast(keyAnd)) && useDefaultANDLinkKey);
	        }

	        /**
	         * 
	         * @param fieldName
	         *            字段名
	         * @param condition
	         *            条件，如"=" "like" 等等
	         * @param value
	         *            要传入的数据
	         */
	        public void append(String fieldName, String condition, String value)
	        {

	            if (value == null || value.length() == 0)
	                return;

	            if (UseDefaultLinkKey())
	                AppendAND();

	            if (condition.toUpperCase().equals("LIKE"))
	            {
	                buffer.append(" " + fieldName + " LIKE '%" + value + "%'");
	            }
	            else
	            {
	                buffer.append(" " + fieldName + " " + condition + " '" + value
	                        + "'");
	            }
	        }

	        /**
	         * 
	         * @param fieldName
	         *            字段名
	         * @param condition
	         *            条件，如"=" ">" "<"等等
	         * @param value
	         *            要传入的数据
	         */
	        public void append(String fieldName, String condition, int value)
	        {
	            if (UseDefaultLinkKey())
	                appendAND();
	            buffer.append(" " + fieldName + " " + condition + " " + value);
	        }

	        /**
	         * 
	         * @param fieldName
	         *            字段名
	         * @param condition
	         *            条件，如"=" ">" "<"等等
	         * @param value
	         *            要传入的数据
	         */
	        public void append(String fieldName, String condition, float value)
	        {
	            if (UseDefaultLinkKey())
	                appendAND();
	            buffer.append(" " + fieldName + " " + condition + " " + value);
	        }

	        /**
	         * 
	         * @param fieldName
	         *            字段名
	         * @param condition
	         *            条件，如"=" ">" "<"等等
	         * @param value
	         *            要传入的数据
	         */
	        public void append(String fieldName, String condition, double value)
	        {
	            if (UseDefaultLinkKey())
	                appendAND();
	            buffer.append(" " + fieldName + " " + condition + " " + value);
	        }

	        /**
	         * 
	         * @param fieldName
	         *            字段名
	         * @param condition
	         *            条件，如"=" ">" "<"等等
	         * @param value
	         *            要传入的数据
	         */
	        public void appendField(String fieldName, String condition, String value)
	        {
	            if (UseDefaultLinkKey())
	                appendAND();
	            buffer.append(" " + fieldName + " " + condition + " " + value);
	        }
	        /**
	         * 
	         * @param fieldName
	         *            字段名
	         * @param condition
	         *            条件，如"=" ">" "<"等等
	         * @param value
	         *            要传入的数据
	         */
	        public void append(String fieldName, String condition, long value)
	        {
	            if (UseDefaultLinkKey())
	                appendAND();
	            buffer.append(" " + fieldName + " " + condition + " " + value);
	        }

	        /**
	         * 添加一个OR关键字，如果多调用一次方法，则最后一个OR会被添加到语句上，即多添加了不会构造出错，即便在语句的最后一个位置
	         * 
	         */
	        public void appendOR()
	        {
	            String tmp = buffer.toString();
	            if (tmp.trim().length() == 0)
	                return;

	            if (!IsValid())
	            {
	                RemoveLastKey();
	            }
	            buffer.append(keyOr);
	        }

	        /**
	         * 添加一个AND关键字，如果多调用一次方法，则最后一个AND会被添加到语句上，即多添加了不会构造出错，即便在语句的最后一个位置
	         * 
	         */
	        public void appendAND()
	        {
	            String tmp = buffer.toString();
	            if (tmp.trim().length() == 0)
	                return;

	            if (!IsValid())
	            {
	                RemoveLastKey();
	            }
	            buffer.append(keyAnd);
	            ;
	        }

	        private boolean IsLast(String key)
	        {

	            String tmpString = buffer.toString();
	            int pos = tmpString.lastIndexOf(key);

	            if (pos == -1)
	            {
	                return false;
	            }

	            if (tmpString.length() == (key.length() + pos))
	            {
	                return true;
	            }
	            else
	            {
	                return false;
	            }

	        }
	        /**
	         * 添加一个AND关键字，如果多调用一次方法，则最后一个AND会被添加到语句上，即多添加了不会构造出错，即便在语句的最后一个位置
	         * 
	         */
	        public void AppendAND()
	        {
	            String tmp = buffer.toString();
	            if (tmp.trim().length() == 0)
	                return;

	            if (!IsValid())
	            {
	                RemoveLastKey();
	            }
	            buffer.append(keyAnd);
	            ;
	        }
	        private boolean IsValid()
	        {
	            //String tmpString = buffer.toString().trim();

	            if (IsLast(keyOr) || IsLast(keyAnd))
	            {
	                return false;
	            }
	            else
	            {
	                return true;
	            }
	        }

	        private void RemoveLastKey()
	        {
	            String tmpStr = buffer.toString().trim();

	            if (!IsValid())
	            {
	                tmpStr = tmpStr.substring(0, tmpStr.length() - keyLen);
	            }
	            buffer = new StringBuffer(tmpStr);
	        }

	        /**
	         * 
	         * @return 返回包括where关键字的条件语句
	         */
	        public String GetWhereClause()
	        {
	            // 去掉最后一个OR 或者 AND语句
	            RemoveLastKey();

	            String tmp = buffer.toString().trim();
	            if (tmp.length() == 0)
	            {
	                return " ";

	            }
	            else
	            {

	                return " where " + buffer.toString();
	            }

	        }
	        public static void main(String args[]) {
	        	WhereClause constructor = new WhereClause(true);
	         constructor.append("name", "like", "TEST");
	        	constructor.appendOR();

	         //constructor.appendAND();

	         //constructor.appendAND();
	         constructor.append("sex", "=", "fe");
	         constructor.appendOR();
	         constructor.append("sex", "=", "fe");
	         constructor.appendOR();
	         constructor.append("sex", "=", "fe");
	         constructor.appendAND();

	        	System.out.println(constructor.GetWhereClause());
	        }
}
